Maîtriser les QuerySets de Django : Étendre les fonctionnalités avec les Managers Personnalisés

            # models.py

from django.db import models
from django.utils import timezone

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # querysets.py (Vous pouvez le placer dans un fichier séparé pour une meilleure organisation, ou dans models.py)

from django.db import models
from django.utils import timezone

class ProductQuerySet(models.QuerySet):
    def available(self):
        """Returns only products that are currently available and not discontinued."""
        now = timezone.now()
        return self.filter(
            is_available=True,
            discontinued_date__isnull=True  # No discontinuation date set
            # Alternatively, if discontinued_date represents a future date:
            # discontinued_date__gt=now 
        )

    def by_price_range(self, min_price, max_price):
        """Filters products within a specified price range."""
        return self.filter(price__gte=min_price, price__lte=max_price)

    def recently_added(self, days=7):
        """Returns products added within the last 'days' days."""
        cutoff_date = timezone.now() - timezone.timedelta(days=days)
        return self.filter(created_at__gte=cutoff_date)

            

              
                Copy
              
            
          

            # managers.py (Encore une fois, pour l'organisation, ou dans models.py)

from django.db import models
from .querysets import ProductQuerySet  # Assuming querysets.py exists

class ProductManager(models.Manager):
    def get_queryset(self):
        return ProductQuerySet(self.model, using=self._db)

    # You can also add methods directly to the manager that might not need
    # to be QuerySet methods, or that serve as entry points to QuerySet methods.
    # For example, a shortcut for the 'available' method:
    def all_available(self):
        return self.get_queryset().available()

    def with_price_range(self, min_price, max_price):
        return self.get_queryset().by_price_range(min_price, max_price)

    def new_items(self, days=7):
        return self.get_queryset().recently_added(days)

            

              
                Copy
              
            
          

            # models.py

from django.db import models
from django.utils import timezone

# Assuming managers.py and querysets.py are in the same app directory
from .managers import ProductManager
# from .querysets import ProductQuerySet # Not directly needed here if manager handles it

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    is_available = models.BooleanField(default=True)
    discontinued_date = models.DateTimeField(null=True, blank=True)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    # Use the custom manager
    objects = ProductManager()

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

            # Dans votre views.py, shell, ou tout autre code Python :

from .models import Product

# Utilisation des raccourcis du manager personnalisé :

# Obtenir tous les produits disponibles globalement
available_products_global = Product.objects.all_available()

# Obtenir les produits dans une fourchette de prix spécifique (par exemple, entre 50 $ et 200 $ USD équivalents)
# Remarque : Pour une véritable gestion des devises internationales, vous auriez besoin d'une logique plus complexe.
# Ici, nous supposons une devise de base ou une tarification équivalente cohérente.
featured_products = Product.objects.with_price_range(50.00, 200.00)

# Obtenir les produits ajoutés au cours des 3 derniers jours
new_arrivals = Product.objects.new_items(days=3)

# Vous pouvez également chaîner les méthodes QuerySet :

# Obtenir les produits disponibles dans une fourchette de prix, triés par date de création
sorted_products = Product.objects.all_available().by_price_range(10.00, 100.00).order_by('-created_at')

# Obtenir tous les produits, puis utiliser les méthodes QuerySet personnalisées :
# C'est moins courant si votre manager fournit un accès direct à ces méthodes.
# Vous utiliseriez généralement Product.objects.available() au lieu de :
# Product.objects.get_queryset().available()

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class PostQuerySet(models.QuerySet):
    def published(self):
        """Returns only published posts available now."""
        return self.filter(is_published=True, published_date__lte=timezone.now())

    def for_locale(self, language_code='en', region_slug=None):
        """Filters posts for a specific language and optional region."""
        qs = self.published().filter(language_code=language_code)
        if region_slug:
            qs = qs.filter(target_regions__slug=region_slug)
        return qs

    def most_recent_for_locale(self, language_code='en', region_slug=None):
        """Gets the single most recently published post for a locale."""
        return self.for_locale(language_code, region_slug).order_by('-published_date').first()

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import render
from .models import Post

def international_post_view(request):
    # Get user's preferred language/region (simplified)
    user_lang = request.GET.get('lang', 'en')
    user_region = request.GET.get('region', None)

    # Get the most recent post for their locale
    latest_post = Post.objects.most_recent_for_locale(language_code=user_lang, region_slug=user_region)

    # Get a list of all available posts in their locale
    all_posts_in_locale = Post.objects.for_locale(language_code=user_lang, region_slug=user_region)

    context = {
        'latest_post': latest_post,
        'all_posts': all_posts_in_locale,
    }
    return render(request, 'posts/international_list.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone

class TaskQuerySet(models.QuerySet):
    def blocked(self):
        """Returns tasks that are currently blocked."""
        return self.filter(status='Blocked')

    def completed_by(self, user):
        """Returns tasks completed by a specific user."""
        return self.filter(status='Completed', completed_by=user)

    def due_soon(self, days=3):
        """Returns tasks due within the next 'days', excluding completed ones."""
        cutoff_date = timezone.now() + timezone.timedelta(days=days)
        return self.exclude(status='Completed').filter(due_date__lte=cutoff_date)

    def active_projects_tasks(self, project):
        """Returns tasks for projects that are currently active."""
        return self.filter(project=project, project__is_active=True)

            

              
                Copy
              
            
          

            # views.py

from django.shortcuts import get_object_or_404
from .models import Task, User, Project

def project_dashboard(request, project_id):
    project = get_object_or_404(Project, pk=project_id)

    # Get tasks for this project that are for active projects (redundant if project object is already fetched)
    # But imagine if it was a global task list related to active projects.
    # Here, we focus on tasks belonging to the specific project:
    
    # Get tasks for the specified project
    project_tasks = Task.objects.filter(project=project)

    # Use custom QuerySet methods on these tasks
    due_tasks = project_tasks.due_soon()
    blocked_tasks = project_tasks.blocked()

    context = {
        'project': project,
        'due_tasks': due_tasks,
        'blocked_tasks': blocked_tasks,
    }
    return render(request, 'project/dashboard.html', context)

            

              
                Copy
              
            
          

            # querysets.py

from django.db import models
from django.utils import timezone
import pytz # Need to install pytz: pip install pytz

class EventQuerySet(models.QuerySet):
    def happening_now(self, current_time=None):
        """Filters events that are currently ongoing, considering their local timezone."""
        if current_time is None:
            current_time = timezone.now() # This is UTC

        # Get all events that might be active based on UTC time range
        potential_events = self.filter(
            start_time__lte=current_time,
            end_time__gte=current_time
        )

        # Further refine by checking local time zone
        # This is tricky as Django ORM doesn't directly support timezone conversions in filters easily.
        # Often, you'd do this conversion in Python after fetching potential events.
        # For demonstration, let's assume a simplified approach where we fetch relevant UTC times
        # and then filter in Python.
        return potential_events # Further refinement would happen in Python code usually

    def happening_today_in_timezone(self, target_timezone_name):
        """Filters events happening today in a specific target timezone."""
        try:
            target_timezone = pytz.timezone(target_timezone_name)
        except pytz.UnknownTimeZoneError:
            return self.none() # Or raise an error

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # Convert today's start and end to the target timezone
        today_start_local = target_timezone.localize(today_start_utc.replace(tzinfo=None))
        today_end_local = target_timezone.localize(today_end_utc.replace(tzinfo=None))

        # We need to convert the event's start/end times to the target timezone for comparison.
        # This is best done in Python for clarity and correctness.
        # For database efficiency, you might store start/end in UTC and the timezone name separately.
        # Then, you'd fetch events whose UTC start/end might overlap with the target day's UTC equivalent.

        # A common ORM-friendly approach is to filter based on the UTC representation of the target day.
        # Find events whose UTC start is before the target day ends, and UTC end is after the target day starts.
        # This includes events that might span across midnight UTC.
        # Then, the specific timezone check is done in Python.
        
        # Simplified approach: Fetch events that start or end within the UTC window of the target day.
        # This needs refinement if events span multiple days and you only want *today* in that zone.
        # A more robust approach involves converting each event's times to the target timezone for comparison.

        # Let's illustrate a Python-side filtering approach:
        qs = self.filter(
            # Basic overlap check in UTC
            start_time__lt=today_end_utc, 
            end_time__gt=today_start_utc
        )
        
        # Now, we'll filter these in Python based on the target timezone
        relevant_events = []
        for event in qs:
            event_start_local = event.start_time.astimezone(target_timezone)
            event_end_local = event.end_time.astimezone(target_timezone)
            
            # Check if any part of the event falls within the target day in the local timezone
            if event_start_local.date() == today_start_local.date() or 
               event_end_local.date() == today_start_local.date() or 
               (event_start_local.date() < today_start_local.date() and event_end_local.date() > today_start_local.date()):
                relevant_events.append(event)
        
        # Return a QuerySet-like object or list.
        # For better integration, you might return a list and wrap it, or use a custom Manager method
        # to handle this more efficiently if possible.
        return relevant_events # This returns a list, not a QuerySet. This is a compromise.


# Let's reconsider the model to make timezone handling clearer

class Event(models.Model):
    name = models.CharField(max_length=255)
    start_time = models.DateTimeField()
    end_time = models.DateTimeField()
    timezone_name = models.CharField(max_length=100, default='UTC') # Store the actual timezone name

    objects = EventManager() # Assume EventManager uses EventQuerySet

    def get_local_start_time(self):
        return self.start_time.astimezone(pytz.timezone(self.timezone_name))

    def get_local_end_time(self):
        return self.end_time.astimezone(pytz.timezone(self.timezone_name))

    def is_happening_now(self):
        now_utc = timezone.now()
        return self.start_time <= now_utc and self.end_time >= now_utc

    def is_happening_today(self):
        now_utc = timezone.now()
        local_tz = pytz.timezone(self.timezone_name)
        
        event_start_local = self.start_time.astimezone(local_tz)
        event_end_local = self.end_time.astimezone(local_tz)
        
        today_local_date = now_utc.astimezone(local_tz).date()
        
        # Check if the event's local duration overlaps with today's local date
        if event_start_local.date() == today_local_date or 
           event_end_local.date() == today_local_date or 
           (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
            return True
        return False


# Revised QuerySet and Manager for timezone-aware events

# querysets.py
from django.db import models
from django.utils import timezone
import pytz

class EventQuerySet(models.QuerySet):
    def for_timezone(self, tz_name):
        """Returns events that are active or will be active today in the given timezone."""
        try:
            tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return self.none()

        now_utc = timezone.now()
        today_start_utc = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
        today_end_utc = today_start_utc + timezone.timedelta(days=1)

        # Find events whose UTC time range overlaps with the UTC equivalent of the target day's range.
        # This is an approximation to reduce the number of events fetched.
        # We are looking for events where:
        # (event.start_time < today_end_utc) AND (event.end_time > today_start_utc)
        # This ensures any overlap, even partial, within the UTC day's span.
        return self.filter(
            start_time__lt=today_end_utc,
            end_time__gt=today_start_utc
        ).order_by('start_time') # Order for easier processing

# managers.py
from django.db import models
from .querysets import EventQuerySet

class EventManager(models.Manager):
    def get_queryset(self):
        return EventQuerySet(self.model, using=self._db)

    def happening_today_in_timezone(self, tz_name):
        """Finds events happening today in the specified timezone."""
        # Fetch potentially relevant events using the QuerySet method
        potential_events_qs = self.get_queryset().for_timezone(tz_name)

        # Now, perform the precise timezone check in Python
        relevant_events = []
        try:
            target_tz = pytz.timezone(tz_name)
        except pytz.UnknownTimeZoneError:
            return [] # Return empty list if timezone is invalid

        # Get the local date for today in the target timezone
        today_local_date = timezone.now().astimezone(target_tz).date()

        for event in potential_events_qs:
            event_start_local = event.start_time.astimezone(target_tz)
            event_end_local = event.end_time.astimezone(target_tz)
            
            # Check for overlap with today's local date
            if event_start_local.date() == today_local_date or 
               event_end_local.date() == today_local_date or 
               (event_start_local.date() < today_local_date and event_end_local.date() > today_local_date):
                relevant_events.append(event)
        
        return relevant_events # This is a list of Event objects.


            

              
                Copy
              
            
          

            # models.py

from django.db import models

class Tenant(models.Model):
    name = models.CharField(max_length=100)
    # ... other tenant details

class TenantAwareQuerySet(models.QuerySet):
    def for_tenant(self, tenant):
        """Filters objects belonging to a specific tenant."""
        if tenant:
            return self.filter(tenant=tenant)
        return self.none() # Or handle appropriately if tenant is None

class TenantAwareManager(models.Manager):
    def get_queryset(self):
        return TenantAwareQuerySet(self.model, using=self._db)

    def for_tenant(self, tenant):
        return self.get_queryset().for_tenant(tenant)

    def active(self):
        """Returns active items for the current tenant (assuming tenant is globally accessible or passed)."""
        # This assumes a mechanism to get the current tenant, e.g., from middleware or thread locals
        from .middleware import get_current_tenant 
        current_tenant = get_current_tenant()
        return self.for_tenant(current_tenant).filter(is_active=True)


class TenantModel(models.Model):
    tenant = models.ForeignKey(Tenant, on_delete=models.CASCADE)
    is_active = models.BooleanField(default=True)
    # ... other fields

    objects = TenantAwareManager()

    class Meta:
        abstract = True # This is a mixin-like pattern

class Customer(TenantModel):
    name = models.CharField(max_length=255)
    # ... other customer fields

# Usage:
# from .models import Customer
# current_tenant = Tenant.objects.get(name='Globex Corp.')
# customers_for_globex = Customer.objects.for_tenant(current_tenant)
# active_customers_globex = Customer.objects.active() # Assumes get_current_tenant() is set correctly

            

              
                Copy